blob: 0f8017d1b14d909ca1151207b6c8c1608dd14879 [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 */
Olivier Houchard9b03c0c2018-07-26 18:45:22 +020086extern volatile 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;
Olivier Houchardb0bdae72018-05-18 18:45:28 +020092extern struct pool_head *pool_head_tasklet;
Willy Tarreaubafbe012017-11-24 17:34:44 +010093extern struct pool_head *pool_head_notification;
Olivier Houchard9b36cb42018-05-04 15:46:16 +020094extern THREAD_LOCAL struct task *curr_task; /* task currently running or NULL */
95extern THREAD_LOCAL struct eb32sc_node *rq_next; /* Next task to be potentially run */
Olivier Houchardb1ca58b2018-06-06 14:22:03 +020096#ifdef USE_THREAD
Willy Tarreaub20aa9e2018-10-15 14:52:21 +020097extern struct eb_root timers; /* sorted timers tree, global */
Olivier Houchardf6e6dc12018-05-18 18:38:23 +020098extern struct eb_root rqueue; /* tree constituting the run queue */
Olivier Houchard77551ee2018-07-26 15:59:38 +020099extern int global_rqueue_size; /* Number of element sin the global runqueue */
Olivier Houchardb1ca58b2018-06-06 14:22:03 +0200100#endif
Olivier Houchard77551ee2018-07-26 15:59:38 +0200101
Willy Tarreau8d8747a2018-10-15 16:12:48 +0200102/* force to split per-thread stuff into separate cache lines */
103struct task_per_thread {
104 struct eb_root timers; /* tree constituting the per-thread wait queue */
105 struct eb_root rqueue; /* tree constituting the per-thread run queue */
106 struct list task_list; /* List of tasks to be run, mixing tasks and tasklets */
107 int task_list_size; /* Number of tasks in the task_list */
108 int rqueue_size; /* Number of elements in the per-thread run queue */
109 __attribute__((aligned(64))) char end[0];
110};
111
112extern struct task_per_thread task_per_thread[MAX_THREADS];
Christopher Faulet9dcf9b62017-11-13 10:34:01 +0100113
114__decl_hathreads(extern HA_SPINLOCK_T rq_lock); /* spin lock related to run queue */
115__decl_hathreads(extern HA_SPINLOCK_T wq_lock); /* spin lock related to wait queue */
Willy Tarreauc6ca1a02007-05-13 19:43:47 +0200116
Olivier Houchard5d187182018-08-01 15:58:44 +0200117
118static inline void task_insert_into_tasklet_list(struct task *t);
119
Willy Tarreau4726f532009-03-07 17:25:21 +0100120/* return 0 if task is in run queue, otherwise non-zero */
121static inline int task_in_rq(struct task *t)
122{
Olivier Houchardb0bdae72018-05-18 18:45:28 +0200123 /* Check if leaf_p is NULL, in case he's not in the runqueue, and if
124 * it's not 0x1, which would mean it's in the tasklet list.
125 */
126 return t->rq.node.leaf_p != NULL && t->rq.node.leaf_p != (void *)0x1;
Willy Tarreau4726f532009-03-07 17:25:21 +0100127}
128
129/* return 0 if task is in wait queue, otherwise non-zero */
130static inline int task_in_wq(struct task *t)
131{
132 return t->wq.node.leaf_p != NULL;
133}
134
Willy Tarreaufdccded2008-08-29 18:19:04 +0200135/* puts the task <t> in run queue with reason flags <f>, and returns <t> */
Olivier Houchardf6e6dc12018-05-18 18:38:23 +0200136/* This will put the task in the local runqueue if the task is only runnable
137 * by the current thread, in the global runqueue otherwies.
138 */
139void __task_wakeup(struct task *t, struct eb_root *);
140static inline void task_wakeup(struct task *t, unsigned int f)
Willy Tarreau4df82062008-08-29 15:26:14 +0200141{
Olivier Houchardf6e6dc12018-05-18 18:38:23 +0200142 unsigned short state;
Emeric Brunc60def82017-09-27 14:59:38 +0200143
Olivier Houchardf6e6dc12018-05-18 18:38:23 +0200144#ifdef USE_THREAD
145 struct eb_root *root;
Emeric Brunc60def82017-09-27 14:59:38 +0200146
Olivier Houchardb0bdae72018-05-18 18:45:28 +0200147 if (t->thread_mask == tid_bit || global.nbthread == 1)
Willy Tarreau8d8747a2018-10-15 16:12:48 +0200148 root = &task_per_thread[tid].rqueue;
Olivier Houchardf6e6dc12018-05-18 18:38:23 +0200149 else
150 root = &rqueue;
151#else
Willy Tarreau8d8747a2018-10-15 16:12:48 +0200152 struct eb_root *root = &task_per_thread[tid].rqueue;
Olivier Houchardf6e6dc12018-05-18 18:38:23 +0200153#endif
154
Willy Tarreau13afcb72019-01-27 17:41:27 +0100155 f |= TASK_QUEUED;
156 state = t->state;
Olivier Houchard4c2832852019-03-08 18:48:47 +0100157 while (!_HA_ATOMIC_CAS(&t->state, &state, state | f))
Willy Tarreau13afcb72019-01-27 17:41:27 +0100158 ;
159 if (!(state & TASK_QUEUED))
Olivier Houchardf6e6dc12018-05-18 18:38:23 +0200160 __task_wakeup(t, root);
Willy Tarreau4df82062008-08-29 15:26:14 +0200161}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200162
Willy Tarreauf65610a2017-10-31 16:06:06 +0100163/* change the thread affinity of a task to <thread_mask> */
Emeric Brunc60def82017-09-27 14:59:38 +0200164static inline void task_set_affinity(struct task *t, unsigned long thread_mask)
165{
Willy Tarreauf65610a2017-10-31 16:06:06 +0100166 t->thread_mask = thread_mask;
Emeric Brunc60def82017-09-27 14:59:38 +0200167}
Willy Tarreauf65610a2017-10-31 16:06:06 +0100168
Willy Tarreau4726f532009-03-07 17:25:21 +0100169/*
170 * Unlink the task from the wait queue, and possibly update the last_timer
171 * pointer. A pointer to the task itself is returned. The task *must* already
172 * be in the wait queue before calling this function. If unsure, use the safer
173 * task_unlink_wq() function.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200174 */
Willy Tarreau4726f532009-03-07 17:25:21 +0100175static inline struct task *__task_unlink_wq(struct task *t)
176{
177 eb32_delete(&t->wq);
Willy Tarreau4726f532009-03-07 17:25:21 +0100178 return t;
179}
180
Willy Tarreaub20aa9e2018-10-15 14:52:21 +0200181/* remove a task from its wait queue. It may either be the local wait queue if
182 * the task is bound to a single thread (in which case there's no locking
183 * involved) or the global queue, with locking.
184 */
Willy Tarreau4726f532009-03-07 17:25:21 +0100185static inline struct task *task_unlink_wq(struct task *t)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200186{
Richard Russobc9d9842019-02-20 12:43:45 -0800187 unsigned long locked;
188
Willy Tarreaub20aa9e2018-10-15 14:52:21 +0200189 if (likely(task_in_wq(t))) {
Richard Russobc9d9842019-02-20 12:43:45 -0800190 locked = atleast2(t->thread_mask);
191 if (locked)
Willy Tarreaub20aa9e2018-10-15 14:52:21 +0200192 HA_SPIN_LOCK(TASK_WQ_LOCK, &wq_lock);
Willy Tarreau4726f532009-03-07 17:25:21 +0100193 __task_unlink_wq(t);
Richard Russobc9d9842019-02-20 12:43:45 -0800194 if (locked)
Willy Tarreaub20aa9e2018-10-15 14:52:21 +0200195 HA_SPIN_UNLOCK(TASK_WQ_LOCK, &wq_lock);
196 }
Willy Tarreau96bcfd72007-04-29 10:41:56 +0200197 return t;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200198}
199
200/*
Christopher Faulet34c5cc92016-12-06 09:15:30 +0100201 * Unlink the task from the run queue. The tasks_run_queue size and number of
202 * niced tasks are updated too. A pointer to the task itself is returned. The
203 * task *must* already be in the run queue before calling this function. If
204 * unsure, use the safer task_unlink_rq() function. Note that the pointer to the
205 * next run queue entry is neither checked nor updated.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200206 */
Willy Tarreau4726f532009-03-07 17:25:21 +0100207static inline struct task *__task_unlink_rq(struct task *t)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200208{
Olivier Houchard4c2832852019-03-08 18:48:47 +0100209 _HA_ATOMIC_SUB(&tasks_run_queue, 1);
Olivier Houchard77551ee2018-07-26 15:59:38 +0200210#ifdef USE_THREAD
211 if (t->state & TASK_GLOBAL) {
Olivier Houchard4c2832852019-03-08 18:48:47 +0100212 _HA_ATOMIC_AND(&t->state, ~TASK_GLOBAL);
Olivier Houchard77551ee2018-07-26 15:59:38 +0200213 global_rqueue_size--;
214 } else
215#endif
Willy Tarreau8d8747a2018-10-15 16:12:48 +0200216 task_per_thread[tid].rqueue_size--;
Olivier Houchard77551ee2018-07-26 15:59:38 +0200217 eb32sc_delete(&t->rq);
Willy Tarreau4726f532009-03-07 17:25:21 +0100218 if (likely(t->nice))
Olivier Houchard4c2832852019-03-08 18:48:47 +0100219 _HA_ATOMIC_SUB(&niced_tasks, 1);
Willy Tarreauce44f122008-07-05 18:16:19 +0200220 return t;
221}
Willy Tarreau9789f7b2008-06-24 08:17:16 +0200222
Willy Tarreau501260b2015-02-23 16:07:01 +0100223/* This function unlinks task <t> from the run queue if it is in it. It also
224 * takes care of updating the next run queue task if it was this task.
225 */
Willy Tarreau4726f532009-03-07 17:25:21 +0100226static inline struct task *task_unlink_rq(struct task *t)
227{
Olivier Houchard1d7f37a2019-03-14 16:14:04 +0100228 int is_global = t->state & TASK_GLOBAL;
229
230 if (is_global)
Olivier Houchardf6e6dc12018-05-18 18:38:23 +0200231 HA_SPIN_LOCK(TASK_RQ_LOCK, &rq_lock);
Olivier Houchard9b36cb42018-05-04 15:46:16 +0200232 if (likely(task_in_rq(t))) {
233 if (&t->rq == rq_next)
234 rq_next = eb32sc_next(rq_next, tid_bit);
Willy Tarreau4726f532009-03-07 17:25:21 +0100235 __task_unlink_rq(t);
Olivier Houchard9b36cb42018-05-04 15:46:16 +0200236 }
Olivier Houchard1d7f37a2019-03-14 16:14:04 +0100237 if (is_global)
Olivier Houchardf6e6dc12018-05-18 18:38:23 +0200238 HA_SPIN_UNLOCK(TASK_RQ_LOCK, &rq_lock);
Willy Tarreau4726f532009-03-07 17:25:21 +0100239 return t;
240}
241
Olivier Houchardb0bdae72018-05-18 18:45:28 +0200242static inline void tasklet_wakeup(struct tasklet *tl)
243{
Olivier Houchard5d187182018-08-01 15:58:44 +0200244 if (!TASK_IS_TASKLET(tl)) {
245 task_insert_into_tasklet_list((struct task *)tl);
246 return;
247 }
Olivier Houcharde17c2d32018-07-17 18:29:22 +0200248 if (!LIST_ISEMPTY(&tl->list))
249 return;
Willy Tarreau8d8747a2018-10-15 16:12:48 +0200250 LIST_ADDQ(&task_per_thread[tid].task_list, &tl->list);
251 task_per_thread[tid].task_list_size++;
Olivier Houchard4c2832852019-03-08 18:48:47 +0100252 _HA_ATOMIC_OR(&active_tasks_mask, tid_bit);
253 _HA_ATOMIC_ADD(&tasks_run_queue, 1);
Olivier Houchardb0bdae72018-05-18 18:45:28 +0200254
255}
256
257static inline void task_insert_into_tasklet_list(struct task *t)
258{
259 struct tasklet *tl;
260 void *expected = NULL;
261
262 /* Protect ourself against anybody trying to insert the task into
263 * another runqueue. We set leaf_p to 0x1 to indicate that the node is
264 * not in a tree but that it's in the tasklet list. See task_in_rq().
265 */
Olivier Houchard4c2832852019-03-08 18:48:47 +0100266 if (unlikely(!_HA_ATOMIC_CAS(&t->rq.node.leaf_p, &expected, (void *)0x1)))
Olivier Houchardb0bdae72018-05-18 18:45:28 +0200267 return;
Olivier Houchard4c2832852019-03-08 18:48:47 +0100268 _HA_ATOMIC_ADD(&tasks_run_queue, 1);
Willy Tarreau8d8747a2018-10-15 16:12:48 +0200269 task_per_thread[tid].task_list_size++;
Olivier Houchardb0bdae72018-05-18 18:45:28 +0200270 tl = (struct tasklet *)t;
Willy Tarreau8d8747a2018-10-15 16:12:48 +0200271 LIST_ADDQ(&task_per_thread[tid].task_list, &tl->list);
Olivier Houchardb0bdae72018-05-18 18:45:28 +0200272}
273
274static inline void task_remove_from_task_list(struct task *t)
275{
Willy Tarreaub238b122019-03-06 19:34:25 +0100276 LIST_DEL_INIT(&((struct tasklet *)t)->list);
Willy Tarreau8d8747a2018-10-15 16:12:48 +0200277 task_per_thread[tid].task_list_size--;
Willy Tarreau1e56c702019-03-07 18:44:12 +0100278 if (!TASK_IS_TASKLET(t))
Olivier Houchard4c2832852019-03-08 18:48:47 +0100279 _HA_ATOMIC_STORE(&t->rq.node.leaf_p, NULL); // was 0x1
280 _HA_ATOMIC_SUB(&tasks_run_queue, 1);
Olivier Houchardb0bdae72018-05-18 18:45:28 +0200281}
282
Willy Tarreauce44f122008-07-05 18:16:19 +0200283/*
284 * Unlinks the task and adjusts run queue stats.
285 * A pointer to the task itself is returned.
286 */
287static inline struct task *task_delete(struct task *t)
288{
Willy Tarreau4726f532009-03-07 17:25:21 +0100289 task_unlink_wq(t);
290 task_unlink_rq(t);
Willy Tarreau9789f7b2008-06-24 08:17:16 +0200291 return t;
292}
293
294/*
Willy Tarreaua4613182009-03-21 18:13:21 +0100295 * Initialize a new task. The bare minimum is performed (queue pointers and
296 * state). The task is returned. This function should not be used outside of
297 * task_new().
Willy Tarreau9789f7b2008-06-24 08:17:16 +0200298 */
Emeric Brunc60def82017-09-27 14:59:38 +0200299static inline struct task *task_init(struct task *t, unsigned long thread_mask)
Willy Tarreau9789f7b2008-06-24 08:17:16 +0200300{
Willy Tarreau4726f532009-03-07 17:25:21 +0100301 t->wq.node.leaf_p = NULL;
302 t->rq.node.leaf_p = NULL;
Olivier Houchardf6e6dc12018-05-18 18:38:23 +0200303 t->state = TASK_SLEEPING;
Willy Tarreauf65610a2017-10-31 16:06:06 +0100304 t->thread_mask = thread_mask;
Willy Tarreau91e99932008-06-30 07:51:00 +0200305 t->nice = 0;
Willy Tarreau3884cba2009-03-28 17:54:35 +0100306 t->calls = 0;
Willy Tarreau9efd7452018-05-31 14:48:54 +0200307 t->call_date = 0;
308 t->cpu_time = 0;
309 t->lat_time = 0;
Willy Tarreauf4219992017-07-24 17:52:58 +0200310 t->expire = TICK_ETERNITY;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200311 return t;
312}
313
Olivier Houchardb0bdae72018-05-18 18:45:28 +0200314static inline void tasklet_init(struct tasklet *t)
315{
316 t->nice = -32768;
317 t->calls = 0;
318 t->state = 0;
Olivier Houchard9ddaf792018-07-19 16:02:16 +0200319 t->process = NULL;
Olivier Houcharddcd6f3a2018-06-08 17:08:19 +0200320 LIST_INIT(&t->list);
Olivier Houchardb0bdae72018-05-18 18:45:28 +0200321}
322
323static inline struct tasklet *tasklet_new(void)
324{
325 struct tasklet *t = pool_alloc(pool_head_tasklet);
326
327 if (t) {
328 tasklet_init(t);
329 }
330 return t;
331}
332
Willy Tarreaubaaee002006-06-26 02:48:02 +0200333/*
Willy Tarreaua4613182009-03-21 18:13:21 +0100334 * Allocate and initialise a new task. The new task is returned, or NULL in
335 * case of lack of memory. The task count is incremented. Tasks should only
336 * be allocated this way, and must be freed using task_free().
337 */
Emeric Brunc60def82017-09-27 14:59:38 +0200338static inline struct task *task_new(unsigned long thread_mask)
Willy Tarreaua4613182009-03-21 18:13:21 +0100339{
Willy Tarreaubafbe012017-11-24 17:34:44 +0100340 struct task *t = pool_alloc(pool_head_task);
Willy Tarreaua4613182009-03-21 18:13:21 +0100341 if (t) {
Olivier Houchard4c2832852019-03-08 18:48:47 +0100342 _HA_ATOMIC_ADD(&nb_tasks, 1);
Emeric Brunc60def82017-09-27 14:59:38 +0200343 task_init(t, thread_mask);
Willy Tarreaua4613182009-03-21 18:13:21 +0100344 }
345 return t;
346}
347
348/*
349 * Free a task. Its context must have been freed since it will be lost.
350 * The task count is decremented.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200351 */
Olivier Houchard9b36cb42018-05-04 15:46:16 +0200352static inline void __task_free(struct task *t)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200353{
Willy Tarreaubafbe012017-11-24 17:34:44 +0100354 pool_free(pool_head_task, t);
Willy Tarreaueb118892014-11-13 16:57:19 +0100355 if (unlikely(stopping))
Willy Tarreaubafbe012017-11-24 17:34:44 +0100356 pool_flush(pool_head_task);
Olivier Houchard4c2832852019-03-08 18:48:47 +0100357 _HA_ATOMIC_SUB(&nb_tasks, 1);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200358}
359
Olivier Houchard9b36cb42018-05-04 15:46:16 +0200360static inline void task_free(struct task *t)
361{
362 /* There's no need to protect t->state with a lock, as the task
363 * has to run on the current thread.
364 */
365 if (t == curr_task || !(t->state & TASK_RUNNING))
366 __task_free(t);
367 else
368 t->process = NULL;
369}
370
Olivier Houchardb0bdae72018-05-18 18:45:28 +0200371static inline void tasklet_free(struct tasklet *tl)
372{
Olivier Houchard09e498f2018-12-24 14:03:10 +0100373 if (!LIST_ISEMPTY(&tl->list)) {
Willy Tarreau8d8747a2018-10-15 16:12:48 +0200374 task_per_thread[tid].task_list_size--;
Olivier Houchard4c2832852019-03-08 18:48:47 +0100375 _HA_ATOMIC_SUB(&tasks_run_queue, 1);
Olivier Houchard09e498f2018-12-24 14:03:10 +0100376 }
Olivier Houcharddcd6f3a2018-06-08 17:08:19 +0200377 LIST_DEL(&tl->list);
378
Olivier Houchardb0bdae72018-05-18 18:45:28 +0200379 pool_free(pool_head_tasklet, tl);
380 if (unlikely(stopping))
381 pool_flush(pool_head_tasklet);
382}
383
Willy Tarreaub20aa9e2018-10-15 14:52:21 +0200384void __task_queue(struct task *task, struct eb_root *wq);
385
Willy Tarreau4726f532009-03-07 17:25:21 +0100386/* Place <task> into the wait queue, where it may already be. If the expiration
Willy Tarreau531cf0c2009-03-08 16:35:27 +0100387 * timer is infinite, do nothing and rely on wake_expired_task to clean up.
Willy Tarreaub20aa9e2018-10-15 14:52:21 +0200388 * If the task is bound to a single thread, it's assumed to be bound to the
389 * current thread's queue and is queued without locking. Otherwise it's queued
390 * into the global wait queue, protected by locks.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200391 */
Willy Tarreau531cf0c2009-03-08 16:35:27 +0100392static inline void task_queue(struct task *task)
393{
394 /* If we already have a place in the wait queue no later than the
395 * timeout we're trying to set, we'll stay there, because it is very
396 * unlikely that we will reach the timeout anyway. If the timeout
397 * has been disabled, it's useless to leave the queue as well. We'll
398 * rely on wake_expired_tasks() to catch the node and move it to the
399 * proper place should it ever happen. Finally we only add the task
400 * to the queue if it was not there or if it was further than what
401 * we want.
402 */
403 if (!tick_isset(task->expire))
404 return;
405
Willy Tarreaub20aa9e2018-10-15 14:52:21 +0200406#ifdef USE_THREAD
407 if (atleast2(task->thread_mask)) {
408 HA_SPIN_LOCK(TASK_WQ_LOCK, &wq_lock);
409 if (!task_in_wq(task) || tick_is_lt(task->expire, task->wq.key))
410 __task_queue(task, &timers);
411 HA_SPIN_UNLOCK(TASK_WQ_LOCK, &wq_lock);
412 } else
413#endif
414 {
415 if (!task_in_wq(task) || tick_is_lt(task->expire, task->wq.key))
Willy Tarreau8d8747a2018-10-15 16:12:48 +0200416 __task_queue(task, &task_per_thread[tid].timers);
Willy Tarreaub20aa9e2018-10-15 14:52:21 +0200417 }
Willy Tarreau531cf0c2009-03-08 16:35:27 +0100418}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200419
Willy Tarreau26e48812011-07-25 14:30:42 +0200420/* Ensure <task> will be woken up at most at <when>. If the task is already in
421 * the run queue (but not running), nothing is done. It may be used that way
422 * with a delay : task_schedule(task, tick_add(now_ms, delay));
423 */
424static inline void task_schedule(struct task *task, int when)
425{
Emeric Brunc60def82017-09-27 14:59:38 +0200426 /* TODO: mthread, check if there is no tisk with this test */
Willy Tarreau26e48812011-07-25 14:30:42 +0200427 if (task_in_rq(task))
428 return;
429
Willy Tarreaub20aa9e2018-10-15 14:52:21 +0200430#ifdef USE_THREAD
431 if (atleast2(task->thread_mask)) {
432 HA_SPIN_LOCK(TASK_WQ_LOCK, &wq_lock);
433 if (task_in_wq(task))
434 when = tick_first(when, task->expire);
435
436 task->expire = when;
437 if (!task_in_wq(task) || tick_is_lt(task->expire, task->wq.key))
438 __task_queue(task, &timers);
439 HA_SPIN_UNLOCK(TASK_WQ_LOCK, &wq_lock);
440 } else
441#endif
442 {
443 if (task_in_wq(task))
444 when = tick_first(when, task->expire);
Willy Tarreau26e48812011-07-25 14:30:42 +0200445
Willy Tarreaub20aa9e2018-10-15 14:52:21 +0200446 task->expire = when;
447 if (!task_in_wq(task) || tick_is_lt(task->expire, task->wq.key))
Willy Tarreau8d8747a2018-10-15 16:12:48 +0200448 __task_queue(task, &task_per_thread[tid].timers);
Willy Tarreaub20aa9e2018-10-15 14:52:21 +0200449 }
Willy Tarreau26e48812011-07-25 14:30:42 +0200450}
451
Thierry FOURNIERd6975962017-07-12 14:31:10 +0200452/* This function register a new signal. "lua" is the current lua
453 * execution context. It contains a pointer to the associated task.
454 * "link" is a list head attached to an other task that must be wake
455 * the lua task if an event occurs. This is useful with external
456 * events like TCP I/O or sleep functions. This funcion allocate
457 * memory for the signal.
458 */
459static inline struct notification *notification_new(struct list *purge, struct list *event, struct task *wakeup)
460{
Willy Tarreaubafbe012017-11-24 17:34:44 +0100461 struct notification *com = pool_alloc(pool_head_notification);
Thierry FOURNIERd6975962017-07-12 14:31:10 +0200462 if (!com)
463 return NULL;
464 LIST_ADDQ(purge, &com->purge_me);
465 LIST_ADDQ(event, &com->wake_me);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100466 HA_SPIN_INIT(&com->lock);
Thierry FOURNIERd6975962017-07-12 14:31:10 +0200467 com->task = wakeup;
468 return com;
469}
470
471/* This function purge all the pending signals when the LUA execution
472 * is finished. This prevent than a coprocess try to wake a deleted
473 * task. This function remove the memory associated to the signal.
Thierry FOURNIERd5b79832017-12-10 17:14:07 +0100474 * The purge list is not locked because it is owned by only one
475 * process. before browsing this list, the caller must ensure to be
476 * the only one browser.
Thierry FOURNIERd6975962017-07-12 14:31:10 +0200477 */
478static inline void notification_purge(struct list *purge)
479{
480 struct notification *com, *back;
481
482 /* Delete all pending communication signals. */
483 list_for_each_entry_safe(com, back, purge, purge_me) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100484 HA_SPIN_LOCK(NOTIF_LOCK, &com->lock);
Thierry FOURNIERd6975962017-07-12 14:31:10 +0200485 LIST_DEL(&com->purge_me);
Thierry FOURNIER738a6d72017-07-17 00:14:07 +0200486 if (!com->task) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100487 HA_SPIN_UNLOCK(NOTIF_LOCK, &com->lock);
Willy Tarreaubafbe012017-11-24 17:34:44 +0100488 pool_free(pool_head_notification, com);
Thierry FOURNIER738a6d72017-07-17 00:14:07 +0200489 continue;
490 }
491 com->task = NULL;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100492 HA_SPIN_UNLOCK(NOTIF_LOCK, &com->lock);
Thierry FOURNIERd6975962017-07-12 14:31:10 +0200493 }
494}
495
Thierry FOURNIERcb146882017-12-10 17:10:57 +0100496/* In some cases, the disconnected notifications must be cleared.
497 * This function just release memory blocs. The purge list is not
498 * locked because it is owned by only one process. Before browsing
499 * this list, the caller must ensure to be the only one browser.
500 * The "com" is not locked because when com->task is NULL, the
501 * notification is no longer used.
502 */
503static inline void notification_gc(struct list *purge)
504{
505 struct notification *com, *back;
506
507 /* Delete all pending communication signals. */
508 list_for_each_entry_safe (com, back, purge, purge_me) {
509 if (com->task)
510 continue;
511 LIST_DEL(&com->purge_me);
512 pool_free(pool_head_notification, com);
513 }
514}
515
Thierry FOURNIERd6975962017-07-12 14:31:10 +0200516/* This function sends signals. It wakes all the tasks attached
517 * to a list head, and remove the signal, and free the used
Thierry FOURNIERd5b79832017-12-10 17:14:07 +0100518 * memory. The wake list is not locked because it is owned by
519 * only one process. before browsing this list, the caller must
520 * ensure to be the only one browser.
Thierry FOURNIERd6975962017-07-12 14:31:10 +0200521 */
522static inline void notification_wake(struct list *wake)
523{
524 struct notification *com, *back;
525
526 /* Wake task and delete all pending communication signals. */
527 list_for_each_entry_safe(com, back, wake, wake_me) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100528 HA_SPIN_LOCK(NOTIF_LOCK, &com->lock);
Thierry FOURNIERd6975962017-07-12 14:31:10 +0200529 LIST_DEL(&com->wake_me);
Thierry FOURNIER738a6d72017-07-17 00:14:07 +0200530 if (!com->task) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100531 HA_SPIN_UNLOCK(NOTIF_LOCK, &com->lock);
Willy Tarreaubafbe012017-11-24 17:34:44 +0100532 pool_free(pool_head_notification, com);
Thierry FOURNIER738a6d72017-07-17 00:14:07 +0200533 continue;
534 }
Thierry FOURNIERd6975962017-07-12 14:31:10 +0200535 task_wakeup(com->task, TASK_WOKEN_MSG);
Thierry FOURNIER738a6d72017-07-17 00:14:07 +0200536 com->task = NULL;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100537 HA_SPIN_UNLOCK(NOTIF_LOCK, &com->lock);
Thierry FOURNIERd6975962017-07-12 14:31:10 +0200538 }
539}
540
Thierry FOURNIER9d5422a2018-05-30 11:40:08 +0200541/* This function returns true is some notification are pending
542 */
543static inline int notification_registered(struct list *wake)
544{
545 return !LIST_ISEMPTY(wake);
546}
547
Willy Tarreaubaaee002006-06-26 02:48:02 +0200548/*
Willy Tarreau918ff602011-07-25 16:33:49 +0200549 * This does 3 things :
Willy Tarreaubaaee002006-06-26 02:48:02 +0200550 * - wake up all expired tasks
551 * - call all runnable tasks
Willy Tarreaud825eef2007-05-12 22:35:00 +0200552 * - return the date of next event in <next> or eternity.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200553 */
554
Thierry FOURNIER9cf7c4b2014-12-15 13:26:01 +0100555void process_runnable_tasks();
Willy Tarreaubaaee002006-06-26 02:48:02 +0200556
Willy Tarreau58b458d2008-06-29 22:40:23 +0200557/*
558 * Extract all expired timers from the timer queue, and wakes up all
559 * associated tasks. Returns the date of next event (or eternity).
560 */
Thierry FOURNIER9cf7c4b2014-12-15 13:26:01 +0100561int wake_expired_tasks();
Willy Tarreau58b458d2008-06-29 22:40:23 +0200562
William Lallemand27f3fa52018-12-06 14:05:20 +0100563/*
564 * Delete every tasks before running the master polling loop
565 */
566void mworker_cleantasks();
567
Willy Tarreaubaaee002006-06-26 02:48:02 +0200568#endif /* _PROTO_TASK_H */
569
570/*
571 * Local variables:
572 * c-indent-level: 8
573 * c-basic-offset: 8
574 * End:
575 */