extern struct pool_head *pool_head_buffer;
extern struct mt_list buffer_wq;
-__decl_hathreads(extern HA_SPINLOCK_T buffer_wq_lock);
+__decl_thread(extern HA_SPINLOCK_T buffer_wq_lock);
int init_buffer();
void buffer_dump(FILE *o, struct buffer *b, int from, int to);
#ifdef CONFIG_HAP_LOCKLESS_POOLS
uintptr_t seq;
#endif
- __decl_hathreads(HA_SPINLOCK_T lock); /* the spin lock */
+ __decl_thread(HA_SPINLOCK_T lock); /* the spin lock */
unsigned int used; /* how many chunks are currently in use */
unsigned int needed_avg;/* floating indicator between used and allocated */
unsigned int allocated; /* how many chunks have been allocated */
#define MAX_THREADS_MASK 1
/* These macros allow to make some struct fields or local variables optional */
-#define __decl_hathreads(decl)
+#define __decl_thread(decl)
#define __decl_spinlock(lock)
#define __decl_aligned_spinlock(lock)
#define __decl_rwlock(lock)
#define MAX_THREADS_MASK (~0UL >> (LONGBITS - MAX_THREADS))
-#define __decl_hathreads(decl) decl
+#define __decl_thread(decl) decl
/* declare a self-initializing spinlock */
#define __decl_spinlock(lock) \
* the pthread identifier which does not exist).
*/
struct thread_info {
- __decl_hathreads(pthread_t pthread);
+ __decl_thread(pthread_t pthread);
clockid_t clock_id;
timer_t wd_timer; /* valid timer or TIMER_INVALID if not set */
uint64_t prev_cpu_time; /* previous per thread CPU time */
/* If we delayed the mux creation because we were waiting for the handshake, do it now */
int conn_create_mux(struct connection *conn);
-__decl_hathreads(extern HA_SPINLOCK_T toremove_lock[MAX_THREADS]);
+__decl_thread(extern HA_SPINLOCK_T toremove_lock[MAX_THREADS]);
/* returns true is the transport layer is ready */
static inline int conn_xprt_ready(const struct connection *conn)
int fd_takeover(int fd, void *expected_owner);
#ifndef HA_HAVE_CAS_DW
-__decl_hathreads(extern HA_RWLOCK_T fd_mig_lock);
+__decl_thread(extern HA_RWLOCK_T fd_mig_lock);
#endif
ssize_t fd_write_frag_line(int fd, size_t maxlen, const struct ist pfx[], size_t npfx, const struct ist msg[], size_t nmsg, int nl);
#include <types/protocol.h>
extern struct protocol *__protocol_by_family[AF_CUST_MAX];
-__decl_hathreads(extern HA_SPINLOCK_T proto_lock);
+__decl_thread(extern HA_SPINLOCK_T proto_lock);
/* Registers the protocol <proto> */
void protocol_register(struct protocol *proto);
#include <proto/freq_ctr.h>
-__decl_hathreads(extern HA_SPINLOCK_T idle_conn_srv_lock);
+__decl_thread(extern HA_SPINLOCK_T idle_conn_srv_lock);
extern struct eb_root idle_conn_srv;
extern struct task *idle_conn_task;
extern struct task *idle_conn_cleanup[MAX_THREADS];
extern int signal_queue_len;
extern struct signal_descriptor signal_state[];
-__decl_hathreads(extern HA_SPINLOCK_T signals_lock);
+__decl_thread(extern HA_SPINLOCK_T signals_lock);
void signal_handler(int sig);
void __signal_process_queue();
extern struct global_ssl global_ssl;
extern struct ssl_bind_kw ssl_bind_kws[];
extern struct methodVersions methodVersions[];
-__decl_hathreads(extern HA_SPINLOCK_T ckch_lock);
+__decl_thread(extern HA_SPINLOCK_T ckch_lock);
extern struct pool_head *pool_head_ssl_capture;
extern unsigned int openssl_engines_initialized;
extern int nb_engines;
extern struct task_per_thread task_per_thread[MAX_THREADS];
-__decl_hathreads(extern HA_SPINLOCK_T rq_lock); /* spin lock related to run queue */
-__decl_hathreads(extern HA_RWLOCK_T wq_lock); /* RW lock related to the wait queue */
+__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);
int arg_opt2; /* extra option 2 for the LB algo (algo-specific) */
int arg_opt3; /* extra option 3 for the LB algo (algo-specific) */
struct server *fbck; /* first backup server when !PR_O_USE_ALL_BK, or NULL */
- __decl_hathreads(HA_SPINLOCK_T lock);
+ __decl_thread(HA_SPINLOCK_T lock);
/* Call backs for some actions. Any of them may be NULL (thus should be ignored). */
void (*update_server_eweight)(struct server *); /* to be called after eweight change */
struct dict {
const char *name;
struct eb_root values;
- __decl_hathreads(HA_RWLOCK_T rwlock);
+ __decl_thread(HA_RWLOCK_T rwlock);
};
#endif /* _TYPES_DICT_H */
struct eb_root query_ids; /* tree to quickly lookup/retrieve query ids currently in use
* used by each nameserver, but stored in resolvers since there must
* be a unique relation between an eb_root and an eb_node (resolution) */
- __decl_hathreads(HA_SPINLOCK_T lock);
+ __decl_thread(HA_SPINLOCK_T lock);
struct list list; /* resolvers list */
};
struct ssl_bind_conf *default_ssl_conf; /* custom SSL conf of default_ctx */
int strict_sni; /* refuse negotiation if sni doesn't match a certificate */
int ssl_options; /* ssl options */
- __decl_hathreads(HA_RWLOCK_T sni_lock); /* lock the SNI trees during add/del operations */
+ __decl_thread(HA_RWLOCK_T sni_lock); /* lock the SNI trees during add/del operations */
struct eb_root sni_ctx; /* sni_ctx tree of all known certs full-names sorted by name */
struct eb_root sni_w_ctx; /* sni_ctx tree of all known certs wildcards sorted by name */
struct tls_keys_ref *keys_ref; /* TLS ticket keys reference */
char *interface; /* interface name or NULL */
char *name; /* listener's name */
- __decl_hathreads(HA_SPINLOCK_T lock);
+ __decl_thread(HA_SPINLOCK_T lock);
const struct netns_entry *netns; /* network namespace of the listener*/
int minlvl;
int maxlen;
struct logsrv *ref;
- __decl_hathreads(HA_SPINLOCK_T lock);
+ __decl_thread(HA_SPINLOCK_T lock);
};
#endif /* _TYPES_LOG_H */
char *display; /* String displayed to identify the pattern origin. */
struct list head; /* The head of the list of struct pat_ref_elt. */
struct list pat; /* The head of the list of struct pattern_expr. */
- __decl_hathreads(HA_SPINLOCK_T lock); /* Lock used to protect pat ref elements */
+ __decl_thread(HA_SPINLOCK_T lock); /* Lock used to protect pat ref elements */
};
/* This is a part of struct pat_ref. Each entry contain one
struct eb_root pattern_tree; /* may be used for lookup in large datasets */
struct eb_root pattern_tree_2; /* may be used for different types */
int mflags; /* flags relative to the parsing or matching method. */
- __decl_hathreads(HA_RWLOCK_T lock); /* lock used to protect patterns */
+ __decl_thread(HA_RWLOCK_T lock); /* lock used to protect patterns */
};
/* This is a list of expression. A struct pattern_expr can be used by
struct shared_table *tables;
struct server *srv;
struct dcache *dcache; /* dictionary cache */
- __decl_hathreads(HA_SPINLOCK_T lock); /* lock used to handle this peer section */
+ __decl_thread(HA_SPINLOCK_T lock); /* lock used to handle this peer section */
struct peer *next; /* next peer in the list */
};
* code even though they are not checks. This structure
* is as a parameter to the check code.
* Each check corresponds to a mailer */
- __decl_hathreads(HA_SPINLOCK_T lock);
+ __decl_thread(HA_SPINLOCK_T lock);
};
struct proxy {
* name is used
*/
struct list filter_configs; /* list of the filters that are declared on this proxy */
- __decl_hathreads(HA_SPINLOCK_T lock); /* may be taken under the server's lock */
+ __decl_thread(HA_SPINLOCK_T lock); /* may be taken under the server's lock */
};
struct switching_rule {
struct buffer buf; // storage area
size_t ofs; // absolute offset in history of the buffer's head
struct list waiters; // list of waiters, for now, CLI "show event"
- __decl_hathreads(HA_RWLOCK_T lock);
+ __decl_thread(HA_RWLOCK_T lock);
int readers_count;
};
} ssl_ctx;
#endif
struct dns_srvrq *srvrq; /* Pointer representing the DNS SRV requeest, if any */
- __decl_hathreads(HA_SPINLOCK_T lock); /* may enclose the proxy's lock, must not be taken under */
+ __decl_thread(HA_SPINLOCK_T lock); /* may enclose the proxy's lock, must not be taken under */
struct {
const char *file; /* file where the section appears */
struct eb32_node id; /* place in the tree of used IDs */
struct server *srv; // used server
struct appctx *appctx; // appctx of current session
size_t ofs; // ring buffer reader offset
- __decl_hathreads(HA_SPINLOCK_T lock); // lock to protect current struct
+ __decl_thread(HA_SPINLOCK_T lock); // lock to protect current struct
struct sink_forward_target *next;
};
struct task *forward_task; // task to handle forward targets conns
struct sig_handler *forward_sighandler; /* signal handler */
struct {
- __decl_hathreads(HA_RWLOCK_T lock); // shared/excl for dropped
+ __decl_thread(HA_RWLOCK_T lock); // shared/excl for dropped
struct ring *ring; // used by ring buffer and STRM sender
unsigned int dropped; // dropped events since last one.
int fd; // fd num for FD type sink
struct list applets; /* all SPOE applets for this agent */
struct list sending_queue; /* Queue of streams waiting to send data */
struct list waiting_queue; /* Queue of streams waiting for a ack, in async mode */
- __decl_hathreads(HA_SPINLOCK_T lock);
+ __decl_thread(HA_SPINLOCK_T lock);
} *rt;
struct {
union tls_sess_key *tlskeys;
int tls_ticket_enc_index;
int key_size_bits;
- __decl_hathreads(HA_RWLOCK_T lock); /* lock used to protect the ref */
+ __decl_thread(HA_RWLOCK_T lock); /* lock used to protect the ref */
};
/* shared ssl session */
struct stksess {
unsigned int expire; /* session expiration date */
unsigned int ref_cnt; /* reference count, can only purge when zero */
- __decl_hathreads(HA_RWLOCK_T lock); /* lock related to the table entry */
+ __decl_thread(HA_RWLOCK_T lock); /* lock related to the table entry */
struct eb32_node exp; /* ebtree node used to hold the session in expiration tree */
struct eb32_node upd; /* ebtree node used to hold the update sequence tree */
struct ebmb_node key; /* ebtree node used to hold the session in table */
struct eb_root exps; /* head of sticky session expiration tree */
struct eb_root updates; /* head of sticky updates sequence tree */
struct pool_head *pool; /* pool used to allocate sticky sessions */
- __decl_hathreads(HA_SPINLOCK_T lock); /* spin lock related to the table */
+ __decl_thread(HA_SPINLOCK_T lock); /* spin lock related to the table */
struct task *exp_task; /* expiration task */
struct task *sync_task; /* sync task */
unsigned int update;
struct list wake_me; /* Part of list of signals to be targeted if an
event occurs. */
struct task *task; /* The task to be wake if an event occurs. */
- __decl_hathreads(HA_SPINLOCK_T lock);
+ __decl_thread(HA_SPINLOCK_T lock);
};
/* force to split per-thread stuff into separate cache lines */
struct list head;
enum vars_scope scope;
unsigned int size;
- __decl_hathreads(HA_RWLOCK_T rwlock);
+ __decl_thread(HA_RWLOCK_T rwlock);
};
/* This struct describes a variable. */
static THREAD_LOCAL struct crypt_data crypt_data = { .initialized = 0 };
#else
/* lock for crypt() */
-__decl_hathreads(static HA_SPINLOCK_T auth_lock);
+__decl_thread(static HA_SPINLOCK_T auth_lock);
#endif
#endif
}
#ifndef HA_HAVE_CAS_DW
-__decl_hathreads(__decl_rwlock(fd_mig_lock));
+__decl_thread(__decl_rwlock(fd_mig_lock));
#endif
/*
struct per_thread_deinit_fct *ptdf;
struct per_thread_free_fct *ptff;
static int init_left = 0;
- __decl_hathreads(static pthread_mutex_t init_mutex = PTHREAD_MUTEX_INITIALIZER);
- __decl_hathreads(static pthread_cond_t init_cond = PTHREAD_COND_INITIALIZER);
+ __decl_thread(static pthread_mutex_t init_mutex = PTHREAD_MUTEX_INITIALIZER);
+ __decl_thread(static pthread_cond_t init_cond = PTHREAD_COND_INITIALIZER);
ha_set_tid((unsigned long)data);
sched = &task_per_thread[tid];
struct sockaddr_storage addr;
socklen_t laddr = sizeof(addr);
unsigned int count;
- __decl_hathreads(unsigned long mask);
+ __decl_thread(unsigned long mask);
/* pre-increase the number of connections without going too far.
* We process the listener, then the proxy, then the process.
#define MEM_FAIL_MAX_STR 128
static int mem_fail_cur_idx;
static char mem_fail_str[MEM_FAIL_MAX_CHAR * MEM_FAIL_MAX_STR];
-__decl_hathreads(static HA_SPINLOCK_T mem_fail_lock);
+__decl_thread(static HA_SPINLOCK_T mem_fail_lock);
int mem_should_fail(const struct pool_head *pool)
{
.list = LIST_HEAD_INIT(srv_keywords.list)
};
-__decl_hathreads(HA_SPINLOCK_T idle_conn_srv_lock);
+__decl_thread(HA_SPINLOCK_T idle_conn_srv_lock);
struct eb_root idle_conn_srv = EB_ROOT;
struct task *idle_conn_task = NULL;
struct task *idle_conn_cleanup[MAX_THREADS] = { NULL };
struct mt_list toremove_connections[MAX_THREADS];
-__decl_hathreads(HA_SPINLOCK_T toremove_lock[MAX_THREADS]);
+__decl_thread(HA_SPINLOCK_T toremove_lock[MAX_THREADS]);
/* The server names dictionary */
struct dict server_name_dict = {
#endif
-__decl_hathreads(HA_SPINLOCK_T ckch_lock);
+__decl_thread(HA_SPINLOCK_T ckch_lock);
/*
struct task_per_thread * const tt = sched; // thread's tasks
struct task *task;
struct eb32_node *eb;
- __decl_hathreads(int key);
+ __decl_thread(int key);
while (1) {
lookup_next_local:
struct task_per_thread * const tt = sched; // thread's tasks
struct eb32_node *eb;
int ret = TICK_ETERNITY;
- __decl_hathreads(int key);
+ __decl_thread(int key);
/* first check in the thread-local timers */
eb = eb32_lookup_ge(&tt->timers, now_ms - TIMER_LOOK_BACK);
projects / thirdparty / haproxy.git / commitdiff
