mirror of
http://git.haproxy.org/git/haproxy.git/
synced 2024-12-23 13:17:16 +00:00
d13a9281bd
We currently have to deal with multiple initialization stages in a way that can be confusing, because certain parts rely on others having been properly initialized. Most calls consist in adding lists to existing lists, whose heads are initialized in the declaration so this is easy. But some calls create new pools and require pools to be properly initialized. Pools currently are thread-local and as such cannot be pre-initialized, requiring run-time checks. All this could be simplified by using multiple boot stages and allowing functions to be registered at various stages. One approach might be to use gcc's constructor priorities, but this requires gcc >= 4.3 which eliminates a wide spectrum of working compilers, and some versions of certain compilers (like clang 3.0) are known for silently ignore these priorities. Instead we can use our own init function registration mechanism. A first attempt was made using register_function() calls in all constructors but this made the code more painful. This patch's approach is different. It creates sections containing arrays of pointers to "initcall" descriptors. An initcall contains a pointer to a function and an argument. Each section corresponds to a specific initialization stage. Each module creates such descriptors for various calls it requires. The main() function starts by scanning each of these sections in turn to process these initcalls. This will make it possible to remove many constructors from various modules, by simply placing initcalls for the requested functions next to the keyword lists that need to be called. A first attempt was made by placing the initcalls directly into the sections instead of creating an array of pointers, but it becomes sensitive to the array's alignment which depends on the compiler and the linker, so it seems too fragile. For now we support 6 init stages : - STG_PREPARE : preset variables, tables and list heads - STG_LOCK : initialize spinlocks and rwlocks - STG_ALLOC : allocate the required structures - STG_POOL : create pools - STG_REGISTER : register static lists (keywords etc) - STG_INIT : subsystems normal initialization These ones are declared directly in the files where they are needed using one of the INITCALL* macros, passing 0 to 3 pointers as arguments. The API should possibly be extended to support a return value to give a status to the caller, and to support a unified API, possibly a bit more flexibility in the arguments. In this case it might make sense to support a set of macros to register functions having a different API and to pass the function type in the initcall itself. Special thanks to Olivier for showing how to scan sections as this is not something particularly well documented and exactly what I've been missing to achieve this.
151 lines
6.2 KiB
C
151 lines
6.2 KiB
C
/*
|
|
* include/common/initcall.h
|
|
*
|
|
* Initcall management.
|
|
*
|
|
* Copyright (C) 2018 Willy Tarreau - w@1wt.eu
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining
|
|
* a copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sublicense, and/or sell copies of the Software, and to
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
* the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be
|
|
* included in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
* OTHER DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
#ifndef _COMMON_INIT_H
|
|
#define _COMMON_INIT_H
|
|
|
|
/* List of known init stages. If others are added, please declare their
|
|
* section at the end of the file below.
|
|
*/
|
|
enum init_stage {
|
|
STG_PREPARE = 0, // preset variables, tables, list heads
|
|
STG_LOCK, // pre-initialize locks
|
|
STG_ALLOC, // allocate required structures
|
|
STG_POOL, // create pools
|
|
STG_REGISTER, // register static lists (keywords etc)
|
|
STG_INIT, // subsystems normal initialization
|
|
STG_SIZE // size of the stages array, must be last
|
|
};
|
|
|
|
/* This is the descriptor for an initcall */
|
|
struct initcall {
|
|
void (*const fct)(void *arg1, void *arg2, void *arg3);
|
|
void *arg1;
|
|
void *arg2;
|
|
void *arg3;
|
|
};
|
|
|
|
/* Declare a static variable in the init section dedicated to stage <stg>,
|
|
* with an element referencing function <function> and arguments <a1..a3>.
|
|
* <linenum> is needed to deduplicate entries created from a same file. The
|
|
* trick with (stg<STG_SIZE) consists in verifying that stg if a valid enum
|
|
* value from the initcall set, and to emit a warning or error if it is not.
|
|
* The function's type is cast so that it is technically possible to call a
|
|
* function taking other argument types, provided they are all the same size
|
|
* as a pointer (args are cast to (void*)). Do not use this macro directly,
|
|
* use INITCALL{0..3}() instead.
|
|
*/
|
|
#define __DECLARE_INITCALL(stg, linenum, function, a1, a2, a3) \
|
|
static const struct initcall *__initcb_##linenum \
|
|
__attribute__((__used__,__section__("init_"#stg))) = \
|
|
(stg < STG_SIZE) ? &(const struct initcall) { \
|
|
.fct = (void (*)(void *,void *,void *))function, \
|
|
.arg1 = (void *)(a1), \
|
|
.arg2 = (void *)(a2), \
|
|
.arg3 = (void *)(a3), \
|
|
} : NULL
|
|
|
|
/* This is used to resolve <linenum> to an integer before calling
|
|
* __DECLARE_INITCALL(). Do not use this macro directly, use INITCALL{0..3}()
|
|
* instead.
|
|
*/
|
|
#define _DECLARE_INITCALL(...) \
|
|
__DECLARE_INITCALL(__VA_ARGS__)
|
|
|
|
/* This requires that function <function> is called with pointer argument
|
|
* <argument> during init stage <stage> which must be one of init_stage.
|
|
*/
|
|
#define INITCALL0(stage, function) \
|
|
_DECLARE_INITCALL(stage, __LINE__, function, 0, 0, 0)
|
|
|
|
/* This requires that function <function> is called with pointer argument
|
|
* <argument> during init stage <stage> which must be one of init_stage.
|
|
*/
|
|
#define INITCALL1(stage, function, arg1) \
|
|
_DECLARE_INITCALL(stage, __LINE__, function, arg1, 0, 0)
|
|
|
|
/* This requires that function <function> is called with pointer arguments
|
|
* <arg1..2> during init stage <stage> which must be one of init_stage.
|
|
*/
|
|
#define INITCALL2(stage, function, arg1, arg2) \
|
|
_DECLARE_INITCALL(stage, __LINE__, function, arg1, arg2, 0)
|
|
|
|
/* This requires that function <function> is called with pointer arguments
|
|
* <arg1..3> during init stage <stage> which must be one of init_stage.
|
|
*/
|
|
#define INITCALL3(stage, function, arg1, arg2, arg3) \
|
|
_DECLARE_INITCALL(stage, __LINE__, function, arg1, arg2, arg3)
|
|
|
|
/* Iterate pointer p (of type initcall**) over all registered calls at
|
|
* stage <stg>.
|
|
*/
|
|
#define FOREACH_INITCALL(p,stg) \
|
|
for ((p) = &(__start_init_##stg); (p) < &(__stop_init_##stg); (p)++)
|
|
|
|
/* Declare a section for stage <stg>. The start and stop pointers are set by
|
|
* the linker itself, which is why they're declared extern here. The weak
|
|
* attribute is used so that we declare them ourselves if the section is
|
|
* empty. The corresponding sections must contain exclusively pointers to
|
|
* make sure each location may safely be visited by incrementing a pointer.
|
|
*/
|
|
#define DECLARE_INIT_SECTION(stg) \
|
|
extern __attribute__((__weak__)) const struct initcall *__start_init_##stg; \
|
|
extern __attribute__((__weak__)) const struct initcall *__stop_init_##stg
|
|
|
|
/* Declare all initcall sections here */
|
|
DECLARE_INIT_SECTION(STG_PREPARE);
|
|
DECLARE_INIT_SECTION(STG_LOCK);
|
|
DECLARE_INIT_SECTION(STG_ALLOC);
|
|
DECLARE_INIT_SECTION(STG_POOL);
|
|
DECLARE_INIT_SECTION(STG_REGISTER);
|
|
DECLARE_INIT_SECTION(STG_INIT);
|
|
|
|
/* not needed anymore */
|
|
#undef DECLARE_INIT_SECTION
|
|
|
|
/* Run the initcalls for stage <stg>. The test on <stg> is only there to
|
|
* ensure it is a valid initcall stage.
|
|
*/
|
|
#define RUN_INITCALLS(stg) \
|
|
do { \
|
|
const struct initcall **ptr; \
|
|
if (stg >= STG_SIZE) \
|
|
break; \
|
|
FOREACH_INITCALL(ptr, stg) \
|
|
(*ptr)->fct((*ptr)->arg1, (*ptr)->arg2, (*ptr)->arg3); \
|
|
} while (0)
|
|
|
|
#endif /* _COMMON_INIT_H */
|
|
|
|
/*
|
|
* Local variables:
|
|
* c-indent-level: 8
|
|
* c-basic-offset: 8
|
|
* End:
|
|
*/
|