RepoMirrors/haproxy
1
0
Fork 0
mirror of http://git.haproxy.org/git/haproxy.git/ synced 2025-02-18 11:47:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

REORG: include: move task.h to haproxy/task{,-t}.h

Browse Source 
The TASK_IS_TASKLET() macro was moved to the proto file instead of the
type one. The proto part was a bit reordered to remove a number of ugly
forward declaration of static inline functions. About a tens of C and H
files had their dependency dropped since they were not using anything
from task.h.
This commit is contained in:
Willy Tarreau 2020-06-04 17:25:40 +02:00
parent f268ee8795
commit cea0e1bb19
48 changed files with 166 additions and 170 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
contrib/debug/flags.c
View File

@ -6,7 +6,7 @@
#include <types/http_ana.h>
#include <types/stream.h>
#include <types/stream_interface.h>
#include <types/task.h>
#include <haproxy/task-t.h>
// 1 bit per flag, no hole permitted here
#define SHOW_AS_ANA 0x00000001

2
contrib/prometheus-exporter/service-prometheus.c
View File

@ -36,7 +36,7 @@
#include <proto/stats.h>
#include <proto/stream.h>
#include <proto/stream_interface.h>
#include <proto/task.h>
#include <haproxy/task.h>
/* Prometheus exporter applet states (appctx->st0) */
enum {

2
include/haproxy/dns-t.h
View File

@ -30,7 +30,7 @@
#include <types/connection.h>
#include <haproxy/proto_udp-t.h>
#include <types/task.h>
#include <haproxy/task-t.h>
extern struct pool_head *dns_requester_pool;

16
include/types/task.h → include/haproxy/task-t.h
View File

@ -1,5 +1,5 @@
/*
* include/types/task.h
* include/haproxy/task-t.h
* Macros, variables and structures for task management.
*
* Copyright (C) 2000-2010 Willy Tarreau - w@1wt.eu
@ -19,16 +19,18 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef _TYPES_TASK_H
#define _TYPES_TASK_H
#ifndef _HAPROXY_TASK_T_H
#define _HAPROXY_TASK_T_H
#include <sys/time.h>
#include <haproxy/api-t.h>
#include <haproxy/list-t.h>
#include <import/eb32sctree.h>
#include <import/eb32tree.h>
#include <haproxy/list-t.h>
#include <haproxy/thread-t.h>
#include <haproxy/api-t.h>
/* values for task->state */
#define TASK_SLEEPING 0x0000 /* task sleeping */
#define TASK_RUNNING 0x0001 /* the task is currently running */
@ -110,8 +112,6 @@ struct tasklet {
int tid; /* TID of the tasklet owner, <0 if local */
};
#define TASK_IS_TASKLET(t) ((t)->nice == -32768)
/*
* The task callback (->process) is responsible for updating ->expire. It must
* return a pointer to the task itself, except if the task has been deleted, in
@ -136,7 +136,7 @@ struct work_list {
void *arg;
};
#endif /* _TYPES_TASK_H */
#endif /* _HAPROXY_TASK_T_H */
/*
* Local variables:

235
include/proto/task.h → include/haproxy/task.h
View File

@ -1,8 +1,8 @@
/*
* include/proto/task.h
* include/haproxy/task.h
* Functions for task management.
*
* Copyright (C) 2000-2010 Willy Tarreau - w@1wt.eu
* Copyright (C) 2000-2020 Willy Tarreau - w@1wt.eu
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@ -19,26 +19,25 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef _PROTO_TASK_H
#define _PROTO_TASK_H
#ifndef _HAPROXY_TASK_H
#define _HAPROXY_TASK_H
#include <sys/time.h>
#include <haproxy/api.h>
#include <haproxy/pool.h>
#include <haproxy/global.h>
#include <haproxy/intops.h>
#include <haproxy/list.h>
#include <haproxy/ticks.h>
#include <haproxy/thread.h>
#include <import/eb32sctree.h>
#include <import/eb32tree.h>
#include <types/task.h>
#include <haproxy/api.h>
#include <haproxy/fd.h>
#include <haproxy/global.h>
#include <haproxy/intops.h>
#include <haproxy/list.h>
#include <haproxy/pool.h>
#include <haproxy/task-t.h>
#include <haproxy/thread.h>
#include <haproxy/ticks.h>
/* Principle of the wait queue.
*
@ -83,6 +82,10 @@
/* The farthest we can look back in a timer tree */
#define TIMER_LOOK_BACK (1U << 31)
/* tasklets are recognized with nice==-32768 */
#define TASK_IS_TASKLET(t) ((t)->nice == -32768)
/* a few exported variables */
extern unsigned int nb_tasks; /* total number of tasks */
extern volatile unsigned long global_tasks_mask; /* Mask of threads with tasks in the global runqueue */
@ -94,6 +97,7 @@ extern struct pool_head *pool_head_task;
extern struct pool_head *pool_head_tasklet;
extern struct pool_head *pool_head_notification;
extern THREAD_LOCAL struct task_per_thread *sched; /* current's thread scheduler context */
#ifdef USE_THREAD
extern struct eb_root timers; /* sorted timers tree, global */
extern struct eb_root rqueue; /* tree constituting the run queue */
@ -105,8 +109,42 @@ extern struct task_per_thread task_per_thread[MAX_THREADS];
__decl_thread(extern HA_SPINLOCK_T rq_lock); /* spin lock related to run queue */
__decl_thread(extern HA_RWLOCK_T wq_lock); /* RW lock related to the wait queue */
static inline struct task *task_unlink_wq(struct task *t);
static inline void task_queue(struct task *task);
void __task_wakeup(struct task *t, struct eb_root *);
void __task_queue(struct task *task, struct eb_root *wq);
struct work_list *work_list_create(int nbthread,
struct task *(*fct)(struct task *, void *, unsigned short),
void *arg);
void work_list_destroy(struct work_list *work, int nbthread);
int run_tasks_from_list(struct list *list, int max);
/*
* This does 3 things :
* - wake up all expired tasks
* - call all runnable tasks
* - return the date of next event in <next> or eternity.
*/
void process_runnable_tasks();
/*
* Extract all expired timers from the timer queue, and wakes up all
* associated tasks.
*/
void wake_expired_tasks();
/* Checks the next timer for the current thread by looking into its own timer
* list and the global one. It may return TICK_ETERNITY if no timer is present.
* Note that the next timer might very well be slightly in the past.
*/
int next_timer_expiry();
/*
* Delete every tasks before running the master polling loop
*/
void mworker_cleantasks();
/* return 0 if task is in run queue, otherwise non-zero */
static inline int task_in_rq(struct task *t)
@ -123,11 +161,21 @@ static inline int task_in_wq(struct task *t)
return t->wq.node.leaf_p != NULL;
}
/* returns true if the current thread has some work to do */
static inline int thread_has_tasks(void)
{
return (!!(global_tasks_mask & tid_bit) |
(sched->rqueue_size > 0) |
!LIST_ISEMPTY(&sched->tasklets[TL_URGENT]) |
!LIST_ISEMPTY(&sched->tasklets[TL_NORMAL]) |
!LIST_ISEMPTY(&sched->tasklets[TL_BULK]) |
!MT_LIST_ISEMPTY(&sched->shared_tasklet_list));
}
/* puts the task <t> in run queue with reason flags <f>, and returns <t> */
/* This will put the task in the local runqueue if the task is only runnable
* by the current thread, in the global runqueue otherwies.
*/
void __task_wakeup(struct task *t, struct eb_root *);
static inline void task_wakeup(struct task *t, unsigned int f)
{
unsigned short state;
@ -152,24 +200,6 @@ static inline void task_wakeup(struct task *t, unsigned int f)
}
}
/* change the thread affinity of a task to <thread_mask>.
* This may only be done from within the running task itself or during its
* initialization. It will unqueue and requeue the task from the wait queue
* if it was in it. This is safe against a concurrent task_queue() call because
* task_queue() itself will unlink again if needed after taking into account
* the new thread_mask.
*/
static inline void task_set_affinity(struct task *t, unsigned long thread_mask)
{
if (unlikely(task_in_wq(t))) {
task_unlink_wq(t);
t->thread_mask = thread_mask;
task_queue(t);
}
else
t->thread_mask = thread_mask;
}
/*
* Unlink the task from the wait queue, and possibly update the last_timer
* pointer. A pointer to the task itself is returned. The task *must* already
@ -201,6 +231,59 @@ static inline struct task *task_unlink_wq(struct task *t)
return t;
}
/* Place <task> into the wait queue, where it may already be. If the expiration
* timer is infinite, do nothing and rely on wake_expired_task to clean up.
* If the task uses a shared wait queue, it's queued into the global wait queue,
* protected by the global wq_lock, otherwise by it necessarily belongs to the
* current thread'sand is queued without locking.
*/
static inline void task_queue(struct task *task)
{
/* If we already have a place in the wait queue no later than the
* timeout we're trying to set, we'll stay there, because it is very
* unlikely that we will reach the timeout anyway. If the timeout
* has been disabled, it's useless to leave the queue as well. We'll
* rely on wake_expired_tasks() to catch the node and move it to the
* proper place should it ever happen. Finally we only add the task
* to the queue if it was not there or if it was further than what
* we want.
*/
if (!tick_isset(task->expire))
return;
#ifdef USE_THREAD
if (task->state & TASK_SHARED_WQ) {
HA_RWLOCK_WRLOCK(TASK_WQ_LOCK, &wq_lock);
if (!task_in_wq(task) || tick_is_lt(task->expire, task->wq.key))
__task_queue(task, &timers);
HA_RWLOCK_WRUNLOCK(TASK_WQ_LOCK, &wq_lock);
} else
#endif
{
BUG_ON((task->thread_mask & tid_bit) == 0); // should have TASK_SHARED_WQ
if (!task_in_wq(task) || tick_is_lt(task->expire, task->wq.key))
__task_queue(task, &sched->timers);
}
}
/* change the thread affinity of a task to <thread_mask>.
* This may only be done from within the running task itself or during its
* initialization. It will unqueue and requeue the task from the wait queue
* if it was in it. This is safe against a concurrent task_queue() call because
* task_queue() itself will unlink again if needed after taking into account
* the new thread_mask.
*/
static inline void task_set_affinity(struct task *t, unsigned long thread_mask)
{
if (unlikely(task_in_wq(t))) {
task_unlink_wq(t);
t->thread_mask = thread_mask;
task_queue(t);
}
else
t->thread_mask = thread_mask;
}
/*
* Unlink the task from the run queue. The tasks_run_queue size and number of
* niced tasks are updated too. A pointer to the task itself is returned. The
@ -419,43 +502,6 @@ static inline void tasklet_set_tid(struct tasklet *tl, int tid)
tl->tid = tid;
}
void __task_queue(struct task *task, struct eb_root *wq);
/* Place <task> into the wait queue, where it may already be. If the expiration
* timer is infinite, do nothing and rely on wake_expired_task to clean up.
* If the task uses a shared wait queue, it's queued into the global wait queue,
* protected by the global wq_lock, otherwise by it necessarily belongs to the
* current thread'sand is queued without locking.
*/
static inline void task_queue(struct task *task)
{
/* If we already have a place in the wait queue no later than the
* timeout we're trying to set, we'll stay there, because it is very
* unlikely that we will reach the timeout anyway. If the timeout
* has been disabled, it's useless to leave the queue as well. We'll
* rely on wake_expired_tasks() to catch the node and move it to the
* proper place should it ever happen. Finally we only add the task
* to the queue if it was not there or if it was further than what
* we want.
*/
if (!tick_isset(task->expire))
return;
#ifdef USE_THREAD
if (task->state & TASK_SHARED_WQ) {
HA_RWLOCK_WRLOCK(TASK_WQ_LOCK, &wq_lock);
if (!task_in_wq(task) || tick_is_lt(task->expire, task->wq.key))
__task_queue(task, &timers);
HA_RWLOCK_WRUNLOCK(TASK_WQ_LOCK, &wq_lock);
} else
#endif
{
BUG_ON((task->thread_mask & tid_bit) == 0); // should have TASK_SHARED_WQ
if (!task_in_wq(task) || tick_is_lt(task->expire, task->wq.key))
__task_queue(task, &sched->timers);
}
}
/* Ensure <task> will be woken up at most at <when>. If the task is already in
* the run queue (but not running), nothing is done. It may be used that way
* with a delay : task_schedule(task, tick_add(now_ms, delay));
@ -586,16 +632,6 @@ static inline int notification_registered(struct list *wake)
return !LIST_ISEMPTY(wake);
}
static inline int thread_has_tasks(void)
{
return (!!(global_tasks_mask & tid_bit) |
(sched->rqueue_size > 0) |
!LIST_ISEMPTY(&sched->tasklets[TL_URGENT]) |
!LIST_ISEMPTY(&sched->tasklets[TL_NORMAL]) |
!LIST_ISEMPTY(&sched->tasklets[TL_BULK]) |
!MT_LIST_ISEMPTY(&sched->shared_tasklet_list));
}
/* adds list item <item> to work list <work> and wake up the associated task */
static inline void work_list_add(struct work_list *work, struct mt_list *item)
{
@ -603,40 +639,7 @@ static inline void work_list_add(struct work_list *work, struct mt_list *item)
task_wakeup(work->task, TASK_WOKEN_OTHER);
}
struct work_list *work_list_create(int nbthread,
struct task *(*fct)(struct task *, void *, unsigned short),
void *arg);
void work_list_destroy(struct work_list *work, int nbthread);
int run_tasks_from_list(struct list *list, int max);
/*
* This does 3 things :
* - wake up all expired tasks
* - call all runnable tasks
* - return the date of next event in <next> or eternity.
*/
void process_runnable_tasks();
/*
* Extract all expired timers from the timer queue, and wakes up all
* associated tasks.
*/
void wake_expired_tasks();
/* Checks the next timer for the current thread by looking into its own timer
* list and the global one. It may return TICK_ETERNITY if no timer is present.
* Note that the next timer might very well be slightly in the past.
*/
int next_timer_expiry();
/*
* Delete every tasks before running the master polling loop
*/
void mworker_cleantasks();
#endif /* _PROTO_TASK_H */
#endif /* _HAPROXY_TASK_H */
/*
* Local variables:

2
include/proto/applet.h
View File

@ -28,7 +28,7 @@
#include <haproxy/pool.h>
#include <haproxy/list.h>
#include <types/applet.h>
#include <proto/task.h>
#include <haproxy/task.h>
extern unsigned int nb_applets;
extern struct pool_head *pool_head_appctx;

2
include/proto/channel.h
View File

@ -40,7 +40,7 @@
#include <types/stream_interface.h>
#include <proto/stream.h>
#include <proto/task.h>
#include <haproxy/task.h>
/* perform minimal intializations, report 0 in case of error, 1 if OK. */
int init_channel();

2
include/proto/connection.h
View File

@ -30,7 +30,7 @@
#include <types/connection.h>
#include <haproxy/fd.h>
#include <proto/session.h>
#include <proto/task.h>
#include <haproxy/task.h>
extern struct pool_head *pool_head_connection;
extern struct pool_head *pool_head_connstream;

1
include/proto/proto_tcp.h
View File

@ -23,7 +23,6 @@
#define _PROTO_PROTO_TCP_H
#include <haproxy/api.h>
#include <types/task.h>
#include <proto/stick_table.h>
int tcp_bind_socket(int fd, int flags, struct sockaddr_storage *local, struct sockaddr_storage *remote);

1
include/proto/queue.h
View File

@ -29,7 +29,6 @@
#include <types/queue.h>
#include <types/stream.h>
#include <types/server.h>
#include <types/task.h>
#include <proto/backend.h>

2
include/proto/signal.h
View File

@ -15,7 +15,7 @@
#include <haproxy/thread.h>
#include <types/signal.h>
#include <types/task.h>
#include <haproxy/task-t.h>
extern int signal_queue_len;
extern struct signal_descriptor signal_state[];

2
include/proto/stream.h
View File

@ -31,7 +31,7 @@
#include <haproxy/obj_type.h>
#include <proto/queue.h>
#include <proto/stick_table.h>
#include <proto/task.h>
#include <haproxy/task.h>
#include <proto/trace.h>
extern struct trace_source trace_strm;

1
include/proto/tcp_rules.h
View File

@ -24,7 +24,6 @@
#include <haproxy/action-t.h>
#include <haproxy/api.h>
#include <types/task.h>
#include <proto/stick_table.h>
int tcp_inspect_request(struct stream *s, struct channel *req, int an_bit);

2
include/types/checks.h
View File

@ -25,7 +25,7 @@
#include <types/connection.h>
#include <haproxy/sample-t.h>
#include <types/session.h>
#include <types/task.h>
#include <haproxy/task-t.h>
/* enum used by check->result. Must remain in this order, as some code uses
* result >= CHK_RES_PASSED to declare success.

2
include/types/server.h
View File

@ -40,7 +40,7 @@
#include <haproxy/freq_ctr-t.h>
#include <types/queue.h>
#include <types/ssl_sock.h>
#include <types/task.h>
#include <haproxy/task-t.h>
#include <types/checks.h>

2
include/types/session.h
View File

@ -34,7 +34,7 @@
#include <haproxy/vars-t.h>
#include <types/stick_table.h>
#include <types/task.h>
#include <haproxy/task-t.h>
struct sess_srv_list {
void *target;

2
include/types/spoe.h
View File

@ -34,7 +34,7 @@
#include <types/proxy.h>
#include <haproxy/sample-t.h>
#include <types/stream.h>
#include <types/task.h>
#include <haproxy/task-t.h>
/* Type of list of messages */
#define SPOE_MSGS_BY_EVENT 0x01

2
include/types/stream.h
View File

@ -43,7 +43,7 @@
#include <types/server.h>
#include <types/session.h>
#include <types/stream_interface.h>
#include <types/task.h>
#include <haproxy/task-t.h>
#include <types/stick_table.h>
/* Various Stream Flags, bits values 0x01 to 0x100 (shift 0) */

2
src/action.c
View File

@ -15,12 +15,12 @@
#include <haproxy/obj_type.h>
#include <haproxy/pool.h>
#include <haproxy/list.h>
#include <haproxy/task.h>
#include <haproxy/tools.h>
#include <proto/log.h>
#include <proto/proxy.h>
#include <proto/stick_table.h>
#include <proto/task.h>
/* Find and check the target table used by an action track-sc*. This

2
src/applet.c
View File

@ -15,11 +15,11 @@
#include <haproxy/api.h>
#include <haproxy/list.h>
#include <haproxy/task.h>
#include <proto/applet.h>
#include <proto/channel.h>
#include <proto/stream.h>
#include <proto/stream_interface.h>
#include <proto/task.h>
unsigned int nb_applets = 0;

2
src/backend.c
View File

@ -31,6 +31,7 @@
#include <haproxy/lb_fwrr.h>
#include <haproxy/obj_type.h>
#include <haproxy/payload.h>
#include <haproxy/task.h>
#include <haproxy/ticks.h>
#include <haproxy/time.h>
#include <haproxy/namespace.h>
@ -55,7 +56,6 @@
#include <proto/stream.h>
#include <proto/stream_interface.h>
#include <proto/ssl_sock.h>
#include <proto/task.h>
#define TRACE_SOURCE &trace_strm

2
src/cfgparse.c
View File

@ -55,6 +55,7 @@
#include <haproxy/time.h>
#include <common/uri_auth.h>
#include <haproxy/namespace.h>
#include <haproxy/task.h>
#include <haproxy/thread.h>
#include <types/filters.h>
@ -79,7 +80,6 @@
#include <proto/server.h>
#include <proto/stream.h>
#include <proto/stick_table.h>
#include <proto/task.h>
#include <proto/tcp_rules.h>
#include <proto/connection.h>

2
src/checks.c
View File

@ -45,6 +45,7 @@
#include <haproxy/http_htx.h>
#include <haproxy/h1.h>
#include <haproxy/htx.h>
#include <haproxy/task.h>
#include <haproxy/vars.h>
#include <haproxy/global.h>
@ -64,7 +65,6 @@
#include <proto/server.h>
#include <proto/signal.h>
#include <proto/stream_interface.h>
#include <proto/task.h>
#include <proto/log.h>
#include <haproxy/proto_udp.h>
#include <proto/ssl_sock.h>

2
src/cli.c
View File

@ -35,6 +35,7 @@
#include <haproxy/mworker-t.h>
#include <haproxy/pattern-t.h>
#include <haproxy/sample-t.h>
#include <haproxy/task.h>
#include <haproxy/tools.h>
#include <haproxy/ticks.h>
#include <haproxy/time.h>
@ -63,7 +64,6 @@
#include <proto/stream.h>
#include <proto/server.h>
#include <proto/stream_interface.h>
#include <proto/task.h>
#define PAYLOAD_PATTERN "<<"

2
src/debug.c
View File

@ -23,6 +23,7 @@
#include <haproxy/buf.h>
#include <haproxy/debug.h>
#include <haproxy/hlua.h>
#include <haproxy/task.h>
#include <haproxy/thread.h>
#include <import/ist.h>
#include <haproxy/net_helper.h>
@ -34,7 +35,6 @@
#include <proto/cli.h>
#include <haproxy/fd.h>
#include <proto/stream_interface.h>
#include <proto/task.h>
/* mask of threads still having to dump, used to respect ordering. Only used
* when USE_THREAD_DUMP is set.

2
src/dns.c
View File

@ -26,6 +26,7 @@
#include <haproxy/errors.h>
#include <haproxy/http_rules.h>
#include <haproxy/sample.h>
#include <haproxy/task.h>
#include <haproxy/time.h>
#include <haproxy/ticks.h>
#include <haproxy/net_helper.h>
@ -43,7 +44,6 @@
#include <proto/http_ana.h>
#include <proto/log.h>
#include <proto/server.h>
#include <proto/task.h>
#include <haproxy/proto_udp.h>
#include <proto/proxy.h>
#include <proto/stream_interface.h>

2
src/flt_spoe.c
View File

@ -20,6 +20,7 @@
#include <haproxy/sample.h>
#include <haproxy/thread.h>
#include <haproxy/pool.h>
#include <haproxy/task.h>
#include <haproxy/time.h>
#include <haproxy/vars.h>
@ -40,7 +41,6 @@
#include <proto/spoe.h>
#include <proto/stream.h>
#include <proto/stream_interface.h>
#include <proto/task.h>
#include <proto/tcp_rules.h>
#if defined(DEBUG_SPOE) || defined(DEBUG_FULL)

2
src/frontend.c
View File

@ -26,6 +26,7 @@
#include <haproxy/chunk.h>
#include <haproxy/frontend.h>
#include <haproxy/sample.h>
#include <haproxy/task.h>
#include <haproxy/tools.h>
#include <haproxy/time.h>
@ -41,7 +42,6 @@
#include <proto/proxy.h>
#include <proto/stream.h>
#include <proto/stream_interface.h>
#include <proto/task.h>
/* Finish a stream accept() for a proxy (TCP or HTTP). It returns a negative
* value in case of a critical failure which must cause the listener to be

2
src/haproxy.c
View File

@ -104,6 +104,7 @@
#include <haproxy/time.h>
#include <common/uri_auth.h>
#include <haproxy/version.h>
#include <haproxy/task.h>
#include <haproxy/thread.h>
#include <haproxy/vars.h>
@ -132,7 +133,6 @@
#include <proto/session.h>
#include <proto/stream.h>
#include <proto/signal.h>
#include <proto/task.h>
#include <proto/ssl_sock.h>
/* array of init calls for older platforms */

2
src/hlua.c
View File

@ -38,6 +38,7 @@
#include <haproxy/pattern.h>
#include <haproxy/payload.h>
#include <haproxy/sample.h>
#include <haproxy/task.h>
#include <haproxy/tools.h>
#include <haproxy/vars.h>
@ -58,7 +59,6 @@
#include <proto/session.h>
#include <proto/stream.h>
#include <proto/stream_interface.h>
#include <proto/task.h>
#include <proto/tcp_rules.h>
/* Lua uses longjmp to perform yield or throwing errors. This

2
src/listener.c
View File

@ -24,6 +24,7 @@
#include <haproxy/global.h>
#include <haproxy/list.h>
#include <haproxy/listener.h>
#include <haproxy/task.h>
#include <haproxy/tools.h>
#include <haproxy/time.h>
@ -38,7 +39,6 @@
#include <haproxy/proto_sockpair.h>
#include <haproxy/sample.h>
#include <proto/stream.h>
#include <proto/task.h>
/* List head of all known bind keywords */
static struct bind_kw_list bind_keywords = {

2
src/mux_pt.c
View File

@ -12,9 +12,9 @@
#include <haproxy/api.h>
#include <haproxy/buf.h>
#include <haproxy/task.h>
#include <proto/connection.h>
#include <proto/stream.h>
#include <proto/task.h>
struct mux_pt_ctx {
struct conn_stream *cs;

2
src/peers.c
View File

@ -25,6 +25,7 @@
#include <haproxy/frontend.h>
#include <haproxy/net_helper.h>
#include <haproxy/obj_type-t.h>
#include <haproxy/task.h>
#include <haproxy/time.h>
#include <haproxy/tools.h>
#include <haproxy/thread.h>
@ -45,7 +46,6 @@
#include <proto/signal.h>
#include <proto/stick_table.h>
#include <proto/stream_interface.h>
#include <proto/task.h>
/*******************************/

1
src/proto_sockpair.c
View File

@ -40,7 +40,6 @@
#include <haproxy/freq_ctr.h>
#include <proto/log.h>
#include <haproxy/protocol.h>
#include <proto/task.h>
static void sockpair_add_listener(struct listener *listener, int port);
static int sockpair_bind_listener(struct listener *listener, char *errmsg, int errlen);

1
src/proto_tcp.c
View File

@ -55,7 +55,6 @@
#include <proto/proto_tcp.h>
#include <proto/proxy.h>
#include <proto/server.h>
#include <proto/task.h>
#include <proto/tcp_rules.h>
static int tcp_bind_listeners(struct protocol *proto, char *errmsg, int errlen);

1
src/proto_uxst.c
View File

@ -39,7 +39,6 @@
#include <haproxy/fd.h>
#include <proto/log.h>
#include <haproxy/protocol.h>
#include <proto/task.h>
static int uxst_bind_listener(struct listener *listener, char *errmsg, int errlen);
static int uxst_bind_listeners(struct protocol *proto, char *errmsg, int errlen);

2
src/proxy.c
View File

@ -24,6 +24,7 @@
#include <haproxy/listener.h>
#include <haproxy/obj_type-t.h>
#include <haproxy/pool.h>
#include <haproxy/task.h>
#include <haproxy/time.h>
#include <import/eb32tree.h>
@ -47,7 +48,6 @@
#include <proto/signal.h>
#include <proto/stream.h>
#include <proto/stream_interface.h>
#include <proto/task.h>
int listeners; /* # of proxy listeners, set by cfgparse */

2
src/queue.c
View File

@ -73,6 +73,7 @@
#include <haproxy/http_rules.h>
#include <haproxy/pool.h>
#include <haproxy/sample.h>
#include <haproxy/task.h>
#include <haproxy/time.h>
#include <haproxy/thread.h>
#include <import/eb32tree.h>
@ -82,7 +83,6 @@
#include <proto/server.h>
#include <proto/stream.h>
#include <proto/stream_interface.h>
#include <proto/task.h>
#include <proto/tcp_rules.h>

1
src/raw_sock.c
View File

@ -35,7 +35,6 @@
#include <proto/log.h>
#include <haproxy/pipe.h>
#include <proto/stream_interface.h>
#include <proto/task.h>
#if defined(USE_LINUX_SPLICE)

2
src/server.c
View File

@ -24,6 +24,7 @@
#include <haproxy/global.h>
#include <haproxy/namespace.h>
#include <haproxy/sample.h>
#include <haproxy/task.h>
#include <haproxy/time.h>
#include <types/applet.h>
@ -42,7 +43,6 @@
#include <proto/stream.h>
#include <proto/stream_interface.h>
#include <proto/stats.h>
#include <proto/task.h>
#include <netinet/tcp.h>
#include <import/ebsttree.h>

2
src/signal.c
View File

@ -13,9 +13,9 @@
#include <signal.h>
#include <string.h>
#include <haproxy/task.h>
#include <proto/signal.h>
#include <proto/log.h>
#include <proto/task.h>
/* Principle : we keep an in-order list of the first occurrence of all received
* signals. All occurrences of a same signal are grouped though. The signal

2
src/ssl_sock.c
View File

@ -56,6 +56,7 @@
#include <haproxy/ssl_ckch.h>
#include <haproxy/ssl_crtlist.h>
#include <haproxy/ssl_utils.h>
#include <haproxy/task.h>
#include <haproxy/tools.h>
#include <haproxy/ticks.h>
#include <haproxy/time.h>
@ -85,7 +86,6 @@
#include <proto/proxy.h>
#include <proto/ssl_sock.h>
#include <proto/stream.h>
#include <proto/task.h>
/* ***** READ THIS before adding code here! *****
*

2
src/stats.c
View File

@ -39,6 +39,7 @@
#include <haproxy/listener.h>
#include <haproxy/map-t.h>
#include <haproxy/pattern-t.h>
#include <haproxy/task.h>
#include <haproxy/tools.h>
#include <haproxy/ticks.h>
#include <haproxy/time.h>
@ -65,7 +66,6 @@
#include <proto/stream.h>
#include <proto/server.h>
#include <proto/stream_interface.h>
#include <proto/task.h>
/* status codes available for the stats admin page (strictly 4 chars length) */
const char *stat_status_codes[STAT_STATUS_SIZE] = {

2
src/stick_table.c
View File

@ -21,6 +21,7 @@
#include <haproxy/pool.h>
#include <haproxy/list.h>
#include <haproxy/net_helper.h>
#include <haproxy/task.h>
#include <haproxy/tools.h>
#include <haproxy/time.h>
@ -40,7 +41,6 @@
#include <proto/stream.h>
#include <proto/stream_interface.h>
#include <proto/stick_table.h>
#include <proto/task.h>
#include <proto/peers.h>
#include <proto/tcp_rules.h>

2
src/stream.c
View File

@ -29,6 +29,7 @@
#include <haproxy/thread.h>
#include <haproxy/htx.h>
#include <haproxy/pool.h>
#include <haproxy/task.h>
#include <haproxy/vars.h>
#include <types/applet.h>
@ -58,7 +59,6 @@
#include <proto/server.h>
#include <proto/stick_table.h>
#include <proto/stream_interface.h>
#include <proto/task.h>
#include <proto/tcp_rules.h>
DECLARE_POOL(pool_head_stream, "stream", sizeof(struct stream));

2
src/stream_interface.c
View File

@ -25,6 +25,7 @@
#include <haproxy/tools.h>
#include <haproxy/ticks.h>
#include <haproxy/time.h>
#include <haproxy/task.h>
#include <proto/applet.h>
#include <proto/channel.h>
@ -33,7 +34,6 @@
#include <proto/proxy.h>
#include <proto/stream.h>
#include <proto/stream_interface.h>
#include <proto/task.h>
#include <haproxy/pipe-t.h>

2
src/task.c
View File

@ -15,6 +15,7 @@
#include <haproxy/api.h>
#include <haproxy/pool.h>
#include <haproxy/list.h>
#include <haproxy/task.h>
#include <haproxy/tools.h>
#include <haproxy/time.h>
#include <import/eb32sctree.h>
@ -24,7 +25,6 @@
#include <haproxy/freq_ctr.h>
#include <proto/proxy.h>
#include <proto/stream.h>
#include <proto/task.h>
DECLARE_POOL(pool_head_task, "task", sizeof(struct task));
DECLARE_POOL(pool_head_tasklet, "tasklet", sizeof(struct tasklet));

2
src/tools.c
View File

@ -46,12 +46,12 @@
#include <haproxy/hlua.h>
#include <haproxy/listener.h>
#include <haproxy/namespace.h>
#include <haproxy/task.h>
#include <haproxy/tools.h>
#include <proto/applet.h>
#include <haproxy/proto_udp.h>
#include <proto/ssl_sock.h>
#include <proto/stream_interface.h>
#include <proto/task.h>
/* This macro returns false if the test __x is false. Many
* of the following parsing function must be abort the processing